1. Field of the Invention
This invention is related to the field of network servers and, more particularly, to the use of cache memory to enhance network server performance.
2. Description of the Related Art
Internet traffic is growing at a rate that greatly exceeds increases in the number of users or the number of transactions. A major factor in this growth is the changing nature of Internet websites themselves. Formerly, web pages comprised mainly static content, such as text, images and links to other sites. The extent of the user""s interaction with the website was to occasionally download an HTML page. And, since the content was the same regardless of who requested the page, it was comparatively simple for the web server to support numerous users. The present trend however, is toward interactive websites in which the content and appearance of the website change in response to user input. This is particularly true for e-commerce sites, which support online product selection and purchasing. Such sites are distinguished from earlier websites by their greater dynamic content. A familiar example of this is the xe2x80x9conline catalogxe2x80x9d provided at many Internet business sites. Each customer logged onto the site to make a purchase has the opportunity to browse the catalog, and even peruse detailed information on thousands of products. Seemingly, the web server must maintain and update a unique web page for each shopper. Internet users enjoy the convenience of such customizable, interactive websites, and customer expectations will undoubtedly provide an impetus for further use of dynamic content in web pages.
The burgeoning use of dynamic content in Internet web pages causes a problem however. Today""s e-commerce sites are characterized by extremely high xe2x80x9cbrowse-to-buy ratios.xe2x80x9d For shopping sites, a typical ratio is 60 interactions that do not update permanent business records (xe2x80x9crequestsxe2x80x9d or xe2x80x9cqueriesxe2x80x9d) to each one that does (xe2x80x9ctransactionsxe2x80x9d)xe2x80x94browsing a product description is an example of a request, while making a purchase exemplifies a transaction. One effect of the increasing prevalence of dynamic content is that, although the number of transactions is growing at a predictable (and manageable) rate, the number of requests is growing explosively. The high user-interactivity of modern dynamic content-based web pages is responsible for the large number of requests per transaction. Dynamic content-based pages must be executed for each user request, to update the user""s browser screen in response to his input. This results in a tremendous amount of content that must be prepared and conveyed to the user during a single session.
Dealing with the sheer volume of Internet traffic may impose an inordinate financial burden on the e-business. User expectations compel the site provider to provide dynamic web content promptly in response to their requests. If potential customers perceive the website as too slow, they may cease visiting the site, resulting in lost business. The obvious way for a website to meet the increasing demand for information by potential customers is to augment its server-side hardwarexe2x80x94i.e., add more computers, routers, etc. But this solution may be prohibitively expensive, and a more cost effective approach is preferable.
One such approach is caching, a technique commonly employed in digital computers to enhance performance. The main memory used in a computer for data storage is typically much slower than the processor. To accommodate the slower memory during a data access, wait states are customarily added to the processor""s normal instruction timing. If the processor were required to always access data from the main memory, its performance would suffer significantly. Caching utilizes a small, but extremely fast memory buffer, and takes advantage of a statistical characteristic known as xe2x80x9cdata localityxe2x80x9d to overcome the main memory access bottleneck. Data locality refers to the common tendency for consecutive data accesses to involve the same general region of memory. This is sometimes stated in terms of the xe2x80x9c80/20xe2x80x9d rulexe2x80x94i.e., 80% of the data accesses are to the same 20% of memory.
The following example, although not web-related, illustrates the benefits of caching in general. Assume we have a computer running a program to multiply two large arrays of numbers, and we want to consider ways the computer might be modified to allow it to run the program faster. The most obvious modification would be to increase the speed of the processorxe2x80x94but this helps only to a point. Each individual multiply operation in the program requires the processor to fetch two operands from memory, compute the product, and then write the result back to memory. At higher processor speeds, as the time required for the computation becomes less significant, the limiting factor is the time required for the processor to interact with memory. Faster memory would seem to be called for, but the use of high-speed memory throughout the computer is too expensive to be practical. Fortunately, the matrix multiplication program exhibits high data locality, since the elements of each of the two input arrays occupy consecutive addresses within a certain range of memory. Therefore, instead of using high-speed memory everywhere in the computer, we employ a small amount of it as a cache. At the start of the program, the input arrays from the main memory are transferred to the cache buffer. While the program executes, the processor fetches operands from the cache, and writes back corresponding results to the cache. Since data accesses use the high-speed cache, the processor is able to execute the program much faster than if it had used main memory. In fact, the use of cache results in a speed improvement nearly as great as if the entire main memory were upgraded, but at a significantly lower cost. Note that a cache system is beneficial only in situations where the assumption of data locality is justifiedxe2x80x94if the processor frequently has to go outside the cache for data, the speed advantage of the cache disappears.
Another issue connected with the use of a data cache is xe2x80x9ccache coherency.xe2x80x9d As described above, data are typically copied to a cache to permit faster access. Each datum in the cache is an identical copy of the original version in main memory. A problem can arise if one application within the computer accesses a variable in main memory, and another application accesses the copy in the cache. If either version of the variable is changed independently of the other, the cache loses coherencyxe2x80x94a potentially harmful result. For example, if the variable is a pointer to critical operating system data, a fatal error may occur. To avoid this, the state of the cache must be monitored. Then, when data in the cache is modified, the xe2x80x9cstalexe2x80x9d copies in the main memory are temporarily invalidated until they can be updated. An important aspect of any cache-equipped system is a mechanism to maintain cache coherency.
As it turns out, web traffic is well suited to caching. As mentioned above, the majority of e-commerce Internet traffic is from the server to the user, rather than vice-versa. In most cases, the user requests information from the website, which must be culled from the website database. Relatively infrequently, the user sends information to the website, which is entered into the website database. Because often, many users request the same information, it is more convenient to cache the information at some point than to repeatedly retrieve it from the database. Caching dynamic web content can improve the responsiveness of the website without a heavy investment in servers and other hardware.
A major consideration for the suitability of caching is the frequency with which the web content changes. Caching generally becomes feasible as the access rate increases and the update rate decreasesxe2x80x94i.e., the user frequently reads from the database, and infrequently writes to the database. If a number of users frequently request the same content, it is much more efficient to fetch it from cache than to repeatedly retrieve it from the database. However, when the content changes almost constantly, the cache must continually be refreshed and provides no advantage. User requests, which update the database, are not cacheable.
FIG. 1 illustrates the hierarchy existing between a website and its users. Each of the web servers, database server and browser clients shown in FIG. 1 is a computer, comprising a central processor, random access memory (RAM), read only memory (ROM), hard disk drive (or other mass storage device), and a network adapter. Those of ordinary skill in the art will appreciate that the exact configuration of the components represented in FIG. 1 may vary, depending on the system implementation. In FIG. 1 the Internet boundary 18 is indicated by a dashed line. The numerous users accessing the website on their Internet browsers are shown above the dashed line, while everything below the line belongs to the website provider. The entire content of the website is maintained in a database, which ultimately resides in some sort of disk storage system 10. Compared to semiconductor memory, disk drives are cheap, have a large storage capacity, and are non-volatile; but they are also much slower. Therefore, it is desirable to avoid frequent access to the disk storage while users access the website. The database is managed by database server 12, which mediates all information entered into the database or retrieved from it. The next level in the hierarchy comprises the web servers 14a-c, that actually supply HTML code over the Internet 18. Internet traffic to and from the browser clients 20a-c is directed by dispatcher 16, which distributes the workload among the web servers 14a-c on an equal basis. Within this hierarchy, the optimum level at which to cache dynamic web content depends on both the nature of the content, and the regularity with which that content must be updated.
Note that each level separating the client from the cache adds to the latency in the perceived response time. For example, if the desired web content were cached in one of the web servers 14a-c, it would be conveyed to the user""s browser 20a-c more quickly than if it were cached in the database server 12, and had to be retrieved by a web server before it could be delivered to the browser. Furthermore, it is generally more efficient for a web server (14a for example) to obtain cached content from one of its fellow web servers (14b or 14c) than for it to fetch it from the database server 12. Therefore, the web servers are closely coupled, and employ their combined caches as a shared resource (xe2x80x9ccluster cachexe2x80x9d).
The format of web pages containing static text and graphic content is typically specified using HTML (HyperText Markup Language). The markup consists of special codes (often called xe2x80x9ctagsxe2x80x9d), which control the display of words and images when the page is read by an Internet browser, such as Internet Explorer, or Netscape. However, Java Server Pages (JSPs) and servlets are more suitable for modern dynamic content-based web pages. In addition to standard HTML, a JSP may contain Java tagsxe2x80x94small programs written in the Java programming language. Java tags are specified on the web page and run on the web server to modify the web page before it is sent to the user who requested it. JSPs and servlets can be nestedxe2x80x94i.e., one JSP or servlet can call another. A JSP or servlet called by another JSP or servlet is referred to as xe2x80x9cnestedxe2x80x9d or xe2x80x9cembeddedxe2x80x9d. A JSP or servlet can also contain commands that deal with either the visual format of the page (display commands), or its content (data commands). In the first case, the output property of the command is HTML, and in the second case, it is data. Thus, a JSP may call a command to get data that is already formatted as HTML, or it may call a command that formats xe2x80x9crawxe2x80x9d data into HTML.
It will be obvious to one skilled in the art that other types of server pages, e.g., Microsoft""s Active Server Pages (ASPs), can also be embedded. Therefore, although a particular embodiment of the system and method disclosed herein deals with JSPs, said system and method are not restricted to this embodiment.
A display command that presents data on a web page is dependent on that data, in the sense that, if the data changes, the command must be invalidated so a new request for it will re-execute it the new data, so the change appears on the page. Consequently, if the display command is cached, it must be invalidated whenever the data upon which it depends is updated. If the command is called from within a cached JSP (e.g., items 62 and 70 in FIG. 2), the JSP is invalidated. Since it is possible for commands to call other commands, and for JSPs to be nested, the chain of dependency can become quite intricate. The caching logic must track these dependencies so that it invalidates the appropriate cache entries whenever the underlying data changes.
Granularity is a characteristic of web pages that is critical to an efficient caching strategy. The content of a web page is comprised of several components, some of which may change frequently, while others are relatively static. Therefore, while it is often impossible to cache an entire page (because it contains components that are too volatile), by caching some of its components we can still beneficially reduce database access. The granularity of a web page may be described in terms of xe2x80x9cfragmentsxe2x80x9d. As used throughout this document, the term xe2x80x9cfragmentxe2x80x9d refers to an HTML page, or a constituent of an HTML page. Each fragment is associated with a visible entity on the web page. A fragment can be created by executing an HTTP request for a JSP file, by calling a JSP from within another JSP, or by executing a command. The following example, which refers to FIG.2, illustrates a web page composed of fragments.
FIG. 2 represents a product display web page, comprising dynamic content fragments 50 and data 52. The top-level fragment is a Java Server Page (JSP) 54, which contains five child fragments, 56-64. Dynamic content data 66-70 are associated with four of child fragments, as discussed in greater detail below. The heavy border around certain fragments or data indicates that they are cached. Note that the child fragments are arranged from left to right in order of increasing rate of change in their underlying data. The product gif URL 56 is a link to an image of the product, and is an output property of the product data command 66, which obtains the image from a database. A formatted table contains a detailed description of the product, and is the output property of display command 58. Because it is used by both the .gif URL 56 and the product display command 58, product data command 66 is cached. Since the product data changes only on a weekly basis, it makes good sense to cache it. This prevents having to retrieve the data from the database each time a prospective customer browses the product web page to peruse the product information. The product display command 58 is cached, since it requires formatting by the server, but .gif URL 56 does not.
A fragment which displays a personalized greeting 60 uses a shopper name fetched from the database by the shopper data command 68. This greeting changes often (for every user), but it is still helpful to cache it, since a given shopper name will be reused over the course of a session by the same user. Note that the greeting fragment 60 does not have to be cached, since no formatting of the shopper name is performed.
A JSP 62 creates an abbreviated shopping cart, calling a shopping cart data command 70 to retrieve the shopping cart data from the database. The shopping cart JSP creates an HTML table to display the data. This content will change even more frequently than the personalized greeting 60, since it must be updated every time the shopper adds something to his cart. Nevertheless, if the shopping cart appears on every page returned to the shopper, it is more efficient to cache the JSP than to retrieve the same data each time the cart is displayed.
An advertisement appearing on the web page displays a URL, which changes each time the page is requested. This is too high an update rate to benefit from caching the associated data command 64. This example illustrates that, although the web page is too volatile to be cached in its entirety, fragment granularity still permit portions of the page to be cached. It is also evident that various types of web content benefit to different degrees from the use of cache.
Not only the content, but the location of the cache, influence the effectiveness of a web cache. Web caches may be broadly categorized as either internal or external. An internal cache is part of the web server itself (item 12 in FIG. 1). External caches can be deployed anywhere between the web server and the Internet boundary (item 18 in FIG. 1). Each type has its own advantages. An external cache can be highly cost effective. It is common to implement external caches in dedicated computers, which, because they don""t have to maintain an operating system, multiple active tasks, etc., can be optimized for this purpose. Moreover, external caches are closer to the client, which in many cases allows them to be more responsive than a server-side cache. On the other hand, an internal cache is able to exploit the fragment and data granularity of a page and cache its less volatile portions. It is easier to implement access control with an internal cache, so that access to certain pages can readily be restricted to specific groups or individuals. Furthermore, an internal cache can be equipped with statistics-tracking capability; this could be used, for example, to monitor the number of customers visiting a particular site. Ideally, a web server with an internal cache can be used to control the external caches. The server could then xe2x80x9cpushxe2x80x9d selected content to the external caches, or invalidate content as needed.
Caching of dynamic web content can improve the responsiveness of an e-commerce website, without incurring the high cost of additional servers. Web caching performance depends on a number of factors. One of these is the frequency with which content must be retrieved from the database. Website performance would improve if cache requests could be satisfied while making fewer database accesses. Another factor affecting performance is redundant execution of requested JSP""s and commands among a group of networked servers. When a server receives a request from a client for a command that is not present in its cache, it normally executes the command and then caches it. However, if the server is part of a group, the command may already be available in the cache of another server, in which case, re-executing the command is inefficient. It would be preferable for the server to attempt to obtain the requested command from one of its peer servers, before executing it locally. Some method for coordination of the execution of cacheable entries among the servers in the group is therefore desirable.
The need for improved responsiveness of an e-commerce website is addressed by the techniques disclosed herein for caching dynamic web content. Under the proper circumstances, caching of dynamic content can shorten the average response time to user requests, without a costly investment in additional servers. Caching is most effective with xe2x80x9cread-onlyxe2x80x9d web trafficxe2x80x94i.e., the direction of information transfer is predominantly from the website to the user. Fortunately, this is the case for most e-business websites.
Disclosed herein are techniques for caching dynamic web content, which are believed to improve the responsiveness of distributed web applications between clients and servers. The context within which these techniques may be applied is preferably an object-oriented software environment. Servers are Java Virtual Machines (JVMs) equipped with a cache, and clients communicate with servers via some type of Internet browser.
In a first embodiment of these techniques, responsiveness is improved by caching read only commands. A class of objects (i.e., cacheable commands) is defined, along with associated methods and properties. Among these are methods adapted to designate a cache, enter a command into a cache, search a cache for a specific command, etc. When a command is requested, the server responding to the request first seeks the command in its local cache. If the command is not found locally, and sharing is enabled, the command is sought in the cache of a peer server. If the command is not cached, the server executes the command and conveys the resulting HIML code to the requesting client, then caches the command. Subsequent requests for the command are serviced from the cache, which is considerably faster than re-executing the command.
In another embodiment, server responsiveness is improved by cofetching read only commands. Special preExecute and postExecute methods of cacheable commands are defined, which allow an application programmer to specify additional commands to be executed by the server and returned to the client, along with the requested command. When the programmer creates a command, he prepares its preExecute method to execute the desired secondary commands and then return them (along with the requested command) to the requesting client. Similarly, the programmer configures the command""s postExecute method to place all the returned commands in a cache.
Thus, a single request can be used to execute, retrieve and cache multiple related commands. The cofetched commands are chosen according to their anticipated use in conjunction with the requested command. For example, a log-on command may cofetch other user authentication commands, since they are generally required immediately after the user logs on. Command cofetching improves server responsiveness by avoiding the need to issue a separate request for every command.
In yet another embodiment, an improvement in server responsiveness is obtained by batching invalidations of cache entries. Cache invalidations require time-consuming updates of invalid cache entries from the database. Therefore, it is advantageous to combine several invalidations and execute them all at once (i.e., to batch them). According to techniques disclosed herein, cache entries may be identified or located on the basis of a unique ID. A list of IDs can be compiled by an application and consulted by a batch invalidation daemon, which uses the IDs therein to invalidate the desired entries. For example, an application can populate an invalidation table with data IDs and then call a batch invalidation daemon, which invokes an xe2x80x9cinvalidateByldxe2x80x9d method to invalidate any entries with that data ID in their metadata. Alternatively, a time limit property of each cache entry can be examined by a time limit invalidation daemon, to invalidate entries that have xe2x80x9ctimed out.xe2x80x9d Note that batching invalidations implies that invalid entries may remain in cache until the batch process is run. However, moderate latency in updating cached data is typically acceptable in e-business applications.
In still another embodiment, a coordinating CacheUnit is associated with each cacheable entry. CacheUnits are present in each server in a server group, and each CacheUnit is capable of executing commands and JSPs and storing them in its cache. Any of the other servers in the group may request an entry from the coordinating CacheUnit associated with that entry. This avoids the need for each server to independently (and redundantly) execute a requested JSP or command if it is not already present in its own cache.